package com.boluo.business.service.impl;

import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;

import com.boluo.business.domain.BusAppointment;
import com.boluo.business.domain.BusStatement;
import com.boluo.business.dto.BusStatementItemDTO;
import com.boluo.business.mapper.BusAppointmentMapper;
import com.boluo.business.mapper.BusStatementMapper;
import com.boluo.common.constant.BusinessConstants;
import com.boluo.common.exception.ServiceException;
import com.boluo.common.utils.DateUtils;
import com.boluo.common.utils.SecurityUtils;
import com.boluo.custom.domain.CusInformation;
import com.boluo.custom.service.ICusInformationService;
import org.springframework.stereotype.Service;
import com.boluo.business.mapper.BusStatementItemMapper;
import com.boluo.business.domain.BusStatementItem;
import com.boluo.business.service.IBusStatementItemService;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import javax.annotation.Resource;

/**
 * 结算单明细Service业务层处理
 *
 * @author boluo
 * @date 2023-04-14
 */
@Service
public class BusStatementItemServiceImpl implements IBusStatementItemService {
    @Resource
    private BusAppointmentMapper busAppointmentMapper;
    @Resource
    private BusStatementMapper busStatementMapper;
    @Resource
    private BusStatementItemMapper busStatementItemMapper;
    @Resource
    private ICusInformationService cusInformationService;

    /**
     * 查询结算单明细
     *
     * @param id 结算单明细主键
     * @return 结算单明细
     */
    @Override
    public BusStatementItem selectBusStatementItemById(Long id) {
        return busStatementItemMapper.selectBusStatementItemById(id);
    }

    /**
     * 查询结算单明细列表
     *
     * @param busStatementItem 结算单明细
     * @return 结算单明细
     */
    @Override
    public List<BusStatementItem> selectBusStatementItemList(BusStatementItem busStatementItem) {
        return busStatementItemMapper.selectBusStatementItemList(busStatementItem);
    }

    /**
     * 新增结算单明细
     *
     * @param busStatementItem 结算单明细
     * @return 结果
     */
    @Override
    public int insertBusStatementItem(BusStatementItem busStatementItem) {
        return busStatementItemMapper.insertBusStatementItem(busStatementItem);
    }

    /**
     * 修改结算单明细
     *
     * @param busStatementItem 结算单明细
     * @return 结果
     */
    @Override
    public int updateBusStatementItem(BusStatementItem busStatementItem) {
        return busStatementItemMapper.updateBusStatementItem(busStatementItem);
    }

    /**
     * 批量删除结算单明细
     *
     * @param ids 需要删除的结算单明细主键
     * @return 结果
     */
    @Override
    public int deleteBusStatementItemByIds(Long[] ids) {
        return busStatementItemMapper.deleteBusStatementItemByIds(ids);
    }

    /**
     * 删除结算单明细信息
     *
     * @param id 结算单明细主键
     * @return 结果
     */
    @Override
    public int deleteBusStatementItemById(Long id) {
        return busStatementItemMapper.deleteBusStatementItemById(id);
    }

    @Override
    @Transactional()
    public int batchAddStatementItem(BusStatementItemDTO busStatementItemDTO) {
        BusStatement originBusStatement = saveStatementItems(busStatementItemDTO);
        // 修改结算单
        return  busStatementMapper.updateBusStatement(originBusStatement);
    }
    /*@Override
    @Transactional()
    public int batchAddStatementItem(BusStatementItemDTO busStatementItemDTO) {
        // 添加结算单明细表受影响的行数
        int count = BusinessConstants.COUNT_ONE;
        // 服务项总数量
        Long totalQuantity = BusinessConstants.TOTAL_SUM_ZERO;
        // 总价格
        BigDecimal totalAmount = BigDecimal.ZERO;


        // 校验参数
        // 结算单id
        Long statementId = busStatementItemDTO.getStatementId();
        Assert.notNull(statementId, "结算单id不能为空");
        // 数据库里的结算单信息
        BusStatement originBusStatement = busStatementMapper.selectBusStatementById(statementId);
        Assert.notNull(originBusStatement, "非法参数");
        // 校验状态
        Integer status = originBusStatement.getStatus();
        Assert.state(status == BusinessConstants.STATEMENT_STATUS_CONSUMER,
                "当前状态不能进行修改");

        // 优惠价格
        BigDecimal discountAmount = busStatementItemDTO.getDiscountAmount();
        Assert.notNull(discountAmount, "优惠价格不能为空");
        Assert.state(discountAmount.compareTo(
                new BigDecimal(BusinessConstants.BIGDECIMAL_ZERO+"")) >=BusinessConstants.COMPARETO_ZERO,
                "优惠价不能为负数不能");
        // 结算单明细集合
        List<BusStatementItem> busStatementItems = busStatementItemDTO.getBusStatementItems();

        // 如果结算单明细里面有旧数据需要进行删除
        // 根据结算单id删除 结算单明细表数据
        busStatementItemMapper.deleteBusStatementItemByStatementId(statementId);
        // 业务操作
        if (busStatementItems.size() > 0){
            for (BusStatementItem busStatementItem : busStatementItems) {
                Long itemQuantity = busStatementItem.getItemQuantity(); // 数量
                BigDecimal itemPrice = busStatementItem.getItemPrice(); // 单价
                BigDecimal multiply = itemPrice.multiply(new BigDecimal(itemQuantity + "")); // 单个结算单明细总价
                // 总服务数量
                totalQuantity += itemQuantity;
                // 总价格
                totalAmount = totalAmount.add(multiply);
            }
            // 批量添加结算单明细
            count = busStatementItemMapper.insertBatch(busStatementItems);

        }
        originBusStatement.setTotalAmount(totalAmount); // 设置总价格
        originBusStatement.setTotalQuantity(new BigDecimal(totalQuantity+"")); // 设置总数量
        originBusStatement.setDiscountAmount(discountAmount); // 设置折扣

        busStatementMapper.updateBusStatement(originBusStatement); // 修改结算单

        return count;
    }*/

    @Override
    @Transactional
    public int payStatement(BusStatementItemDTO busStatementItemDTO) {
        BusStatement originBusStatement = saveStatementItems(busStatementItemDTO);

        // 校验状态
        Integer status = originBusStatement.getStatus();
        Assert.state(status == BusinessConstants.STATEMENT_STATUS_CONSUMER,
                "当前状态不能进行支付");

        // 业务逻辑
        // 支付功能(假支付)

        // 设置状态为已支付
        originBusStatement.setStatus(BusinessConstants.STATEMENT_STATUS_PRICE);
        // 设置支付时间
        originBusStatement.setPayTime(DateUtils.getNowDate());
        // 设置收款人id
        originBusStatement.setPayeeId(SecurityUtils.getUserId());

        // 修改预约单状态 改为已支付
        Long appointmentId = originBusStatement.getAppointmentId();
        if (Objects.nonNull(appointmentId)) {
            BusAppointment busAppointment = busAppointmentMapper.selectBusAppointmentById(appointmentId);
            Integer originStatus = busAppointment.getStatus();
            Assert.state(originStatus == BusinessConstants.APPOINTMENT_STATUS_SETTLED,"当前状态错误,无法操作");
            busAppointment.setStatus(BusinessConstants.APPOINTMENT_STATUS_PAYED);
            busAppointmentMapper.updateBusAppointment(busAppointment);

        }

        // 做客户归档操作 =============================
        CusInformation cusInformation = new CusInformation();
        cusInformation.setCusName(originBusStatement.getCustomerName());
        cusInformation.setCusPhone(originBusStatement.getCustomerPhone());
        cusInformation.setCusCarName(originBusStatement.getCarSeries());
        cusInformationService.insertCusInformation(cusInformation);


        return busStatementMapper.updateBusStatement(originBusStatement);
    }

    private BusStatement saveStatementItems(BusStatementItemDTO busStatementItemDTO) {
        // 服务项总数量
        Long totalQuantity = BusinessConstants.TOTAL_SUM_ZERO;
        // 总价格
        BigDecimal totalAmount = BigDecimal.ZERO;


        // 校验参数
        // 结算单id
        Long statementId = busStatementItemDTO.getStatementId();
        Assert.notNull(statementId, "结算单id不能为空");
        // 数据库里的结算单信息
        BusStatement originBusStatement = busStatementMapper.selectBusStatementById(statementId);
        Assert.notNull(originBusStatement, "非法参数");
        // 校验状态
        Integer status = originBusStatement.getStatus();
        Assert.state(status == BusinessConstants.STATEMENT_STATUS_CONSUMER,
                "当前状态不能进行修改");

        // 优惠价格
        BigDecimal discountAmount = busStatementItemDTO.getDiscountAmount();
        Assert.notNull(discountAmount, "优惠价格不能为空");
        Assert.state(discountAmount.compareTo(
                new BigDecimal(BusinessConstants.BIGDECIMAL_ZERO+"")) >=BusinessConstants.COMPARETO_ZERO,
                "优惠价不能为负数不能");
        // 结算单明细集合
        List<BusStatementItem> busStatementItems = busStatementItemDTO.getBusStatementItems();

        // 如果结算单明细里面有旧数据需要进行删除
        // 根据结算单id删除 结算单明细表数据
        busStatementItemMapper.deleteBusStatementItemByStatementId(statementId);
        // 业务操作
        if (busStatementItems.size() > 0){
            for (BusStatementItem busStatementItem : busStatementItems) {
                if (!statementId.equals(busStatementItem.getStatementId())){
                    throw new ServiceException("非法参数");
                }
                // 添加结算单明细
                busStatementItemMapper.insertBusStatementItem(busStatementItem);
                Long itemQuantity = busStatementItem.getItemQuantity(); // 数量
                BigDecimal itemPrice = busStatementItem.getItemPrice(); // 单价
                BigDecimal multiply = itemPrice.multiply(new BigDecimal(itemQuantity + "")); // 单个结算单明细总价
                // 总服务数量
                totalQuantity += itemQuantity;
                // 总价格
                totalAmount = totalAmount.add(multiply);
            }

        }

        originBusStatement.setTotalAmount(totalAmount); // 设置总价格
        originBusStatement.setTotalQuantity(new BigDecimal(totalQuantity+"")); // 设置总数量
        originBusStatement.setDiscountAmount(discountAmount); // 设置折扣

        return originBusStatement;
    }
}
